package com.br.imovel.controller;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
import com.br.imovel.ejb.AvaliacaoEJBLocal;
import com.br.imovel.ejb.ItemEJBLocal;
import com.br.imovel.ejb.PreenchimentoEJBLocal;
import com.br.imovel.ejb.PreenchimentoRespostaEJBLocal;
import com.br.imovel.ejb.TurmaEJBLocal;
import com.br.imovel.model.Aluno;
import com.br.imovel.model.Avaliacao;
import com.br.imovel.model.Item;
import com.br.imovel.model.Preenchimento;
import com.br.imovel.model.PreenchimentoResposta;
import com.br.imovel.model.Questao;
import com.br.imovel.model.Turma;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.ejb.EJB;
import javax.faces.application.FacesMessage;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.SessionScoped;
import javax.faces.context.FacesContext;
import javax.faces.model.DataModel;
import javax.faces.model.ListDataModel;
import javax.faces.model.SelectItem;
import org.apache.log4j.BasicConfigurator;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;

/**
 *
 * @author leandro
 */
@ManagedBean(name = "avaliacaoM")
@SessionScoped
public class AvaliacaoMBean implements Serializable {

    @EJB
    private AvaliacaoEJBLocal avaliacaoEJB;
    @EJB
    private ItemEJBLocal itemAvaliacaoEJB;
    @EJB
    private TurmaEJBLocal turmaEJB;
    @EJB
    private PreenchimentoEJBLocal preenchimentoEJB;
    @EJB
    private PreenchimentoRespostaEJBLocal preeRespostaEJB;
    private Preenchimento preenchimento;
    private List<PreenchimentoResposta> preeListResposta;
    private PreenchimentoResposta preenchimentoResposta;
    private Avaliacao entidade;
    private Avaliacao[] entidadesSelecionadas;
    private DataModel entidades;
    private FacesMessage msg;
    private Logger log;
    private List<SelectItem> listaTurmas;

    public List<SelectItem> getListaTurmas() {
        listaTurmas = new ArrayList<SelectItem>();
        listaTurmas.add(new SelectItem(null, ""));
        List<Turma> turmas;
        try {
            turmas = turmaEJB.recuperaTodos();
            for (Turma turma : turmas) {
                listaTurmas.add(new SelectItem(turma.getId(), turma.getNome() + "- [" + turma.getId() + "]"));
            }
        } catch (Exception e) {
            empilhaMensagem(FacesMessage.SEVERITY_ERROR, "Erro eo recuperar lista de modulos", null);
            log.error("Erro eo recuperar lista de salas");
            listaTurmas.add(new SelectItem(null, "Erro eo recuperar lista de modulos"));
        }
        return listaTurmas;
    }

    public void setListaTurma(List<SelectItem> listaTurma) {
        this.listaTurmas = listaTurma;
    }

    public AvaliacaoMBean() {
        log = Logger.getLogger(AvaliacaoMBean.class);
        BasicConfigurator.configure();
        log.setLevel(Level.ALL);
        log.info("entrou no construtor");
        iniciaDados();
    }

    public Avaliacao[] getEntidadesSelecionadas() {
        return entidadesSelecionadas;
    }

    public void setEntidadesSelecionadas(Avaliacao[] entidadesSelecionadas) {
        this.entidadesSelecionadas = entidadesSelecionadas;
    }

    public void log(String mensagem, Level level, Exception e) {
        if (level == Level.FATAL) {
            log.fatal(System.currentTimeMillis() + mensagem, e);
        } else if (level == Level.ERROR) {
            log.error(System.currentTimeMillis() + mensagem, e);
        } else if (level == Level.WARN) {
            log.warn(System.currentTimeMillis() + mensagem, e);
        } else if (level == Level.INFO) {
            log.info(System.currentTimeMillis() + mensagem, e);
        } else if (level == Level.TRACE) {
            log.trace(System.currentTimeMillis() + mensagem, e);
        }

    }

    public Avaliacao getEntidade() {
        return entidade;
    }

    public void setEntidade(Avaliacao entidade) {
        this.entidade = entidade;

        selectedItemAvaliacao.clear();
        if (this.getEntidade().getItens() != null && !this.getEntidade().getItens().isEmpty()) {
            for (Item item : this.getEntidade().getItens()) {
                selectedItemAvaliacao.add(item.getId().toString());
            }
        }

        selectedTurmas.clear();
        if (this.getEntidade().getTurmas() != null && !this.getEntidade().getTurmas().isEmpty()) {
            for (Turma turma : this.getEntidade().getTurmas()) {
                selectedTurmas.add(turma.getId().toString());
            }
        }



        log.trace("setEntidade:" + entidade);

    }

    public void setEntidadeDuplicar(Avaliacao entidade) {
        this.entidade = entidade;
        this.entidade.setId(null);
        log.trace("setEntidadeDuplicar:" + entidade);

    }

    public DataModel getEntidades() {
        if (entidades == null) {
            List<Avaliacao> lista = avaliacaoEJB.recuperaTodos();
            log.trace("getEntidades :" + lista);
            entidades = new ListDataModel(lista);
        }
        populaListaItemAvaliacao();
        populaListaTurmas();
        return entidades;
    }

    public void setEntidades(DataModel entidades) {
        this.entidades = entidades;



    }

    public void prepararAdicionarEntidade() {
        this.entidade = new Avaliacao();
        List<Turma> turmas = new ArrayList<Turma>();
        turmas.add(new Turma());
        this.entidade.setTurmas(turmas);
        selectedItemAvaliacao = null;
        log.info("prepara Adicionar entidade :" + entidade);

    }

    public void prepararDuplicarEntidade() {
        this.entidade.setId(null);


        log.info("prepara Duplicar Entidade :" + entidade);
    }

    public void salvaEntidade() {
        if (this.getEntidade() != null) {

            List<Item> listItemAvaliacao = new ArrayList<Item>();

            for (int i = 0; i < selectedItemAvaliacao.size(); i++) {
                Long idItemAvaliacao = Long.parseLong(selectedItemAvaliacao.get(i));
                listItemAvaliacao.add(itemAvaliacaoEJB.recupera(idItemAvaliacao));
            }

            this.getEntidade().setItens(listItemAvaliacao);

            List<Turma> listTurma = new ArrayList<Turma>();

            for (int i = 0; i < selectedTurmas.size(); i++) {
                Long idItemAvaliacao = Long.parseLong(selectedTurmas.get(i));
                listTurma.add(turmaEJB.recupera(idItemAvaliacao));
            }

            this.getEntidade().setTurmas(listTurma);

            if (this.getEntidade().getId() == null) {
                avaliacaoEJB.novo(entidade);
                empilhaMensagem(FacesMessage.SEVERITY_INFO, "Registro salvo com sucesso " + entidade.getId(), null);

            } else {
                avaliacaoEJB.atualiza(entidade);
                empilhaMensagem(FacesMessage.SEVERITY_INFO, "Registro atualizado com sucesso " + entidade.getId(), null);
            }


            iniciaDados();
        }
    }

    public void removerEntidade() {
        log.info("Remover  Entidade :" + entidade);
        avaliacaoEJB.remove(entidade);
        empilhaMensagem(FacesMessage.SEVERITY_INFO, "Registro removido com sucesso " + entidade.getId(), null);
        iniciaDados();
    }

    public void ativar() {

        List<Turma> turmas = entidade.getTurmas();
        for (Turma turma : turmas) {
            try {


                List<Aluno> alunos = turma.getAlunos();
                for (Aluno aluno : alunos) {
                    preeListResposta = new ArrayList<PreenchimentoResposta>();
                    preenchimento = new Preenchimento();
                    preenchimento.setAvaliacao(entidade);
                    preenchimento.setTurma(turma);
                    preenchimento.setAluno(aluno);

                    for (Item item : entidade.getItens()) {
                        for (Questao questao2 : item.getQuestoes()) {
                            preenchimentoResposta = new PreenchimentoResposta();

                            preenchimentoResposta.setQuestao(questao2);
                            
                            preeListResposta.add(preenchimentoResposta);
                            // preeResposta = preeRespostaEJB.novoId(preeResposta);
                        }

                    }
                    preenchimento.setPreenchimentosRespostas(preeListResposta);
                    if (preenchimento.getId() == null) {
                        preenchimentoEJB.novo(preenchimento);
                    } else {
                        preenchimentoEJB.atualiza(preenchimento);
                    }

                }
                empilhaMensagem(FacesMessage.SEVERITY_INFO, "Avaliação Ativado com sucesso " + entidade.getId(), null);

            } catch (Exception e) {
                empilhaMensagem(FacesMessage.SEVERITY_ERROR, "Erro ao  Ativado Avaliação " + e.getMessage(), null);

            }


        }


        log.info("Ativar  Entidade :" + entidade);
        iniciaDados();
    }

    public void removerEntidadesSelecionadas() {
        log.trace("Remover  Entidades Selecionadas :" + entidadesSelecionadas);
        empilhaMensagem(FacesMessage.SEVERITY_INFO, "Registros removidos  com sucesso, total de  " + this.entidadesSelecionadas.length, null);
        for (Avaliacao entidadeAtual : entidadesSelecionadas) {
            avaliacaoEJB.remove(entidadeAtual);
        }
        iniciaDados();
    }

    private void iniciaDados() {

        this.entidades = null;
        this.entidade = new Avaliacao();
        List<Turma> turmas = new ArrayList<Turma>();
        turmas.add(new Turma());
        this.entidade.setTurmas(turmas);

        this.entidadesSelecionadas = null;
        this.selectedItemAvaliacao = new ArrayList<String>();
        this.selectedTurmas = new ArrayList<String>();

        itemAvaliacao = new HashMap<String, Long>();
        turmaMap = new HashMap<String, Long>();
        log.trace("Limpar dados das  Entidades :");

    }

    private void empilhaMensagem(FacesMessage.Severity tipoMensagem, String titulo, String mensagem) {
        msg = new FacesMessage(tipoMensagem, titulo, mensagem);
        FacesContext.getCurrentInstance().addMessage(null, this.msg);

    }

    private void populaListaItemAvaliacao() {

        itemAvaliacao = new HashMap<String, Long>();

        for (Item itemAvaliacaoAtual : itemAvaliacaoEJB.recuperaTodos()) {
            itemAvaliacao.put(itemAvaliacaoAtual.getNome(), itemAvaliacaoAtual.getId());
        }

    }

    private void populaListaTurmas() {

        turmaMap = new HashMap<String, Long>();

        for (Turma turma : turmaEJB.recuperaTodos()) {
            turmaMap.put(turma.getNome(), turma.getId());
        }
    }
    private List<String> selectedItemAvaliacao;
    private Map<String, Long> itemAvaliacao;
    private List<String> selectedTurmas;
    private Map<String, Long> turmaMap;

    public List<String> getSelectedTurmas() {
        return selectedItemAvaliacao;
    }

    public void setSelectedTurmas(List<String> selectedTurmas) {
        this.selectedTurmas = selectedTurmas;
    }

    public List<String> getSelectedItemAvaliacao() {
        return selectedItemAvaliacao;
    }

    public void setSelectedItemAvaliacao(List<String> selectedItemAvaliacao) {
        this.selectedItemAvaliacao = selectedItemAvaliacao;
    }

    public Map<String, Long> getTurmas() {
        return turmaMap;
    }

    public void setTurmas(Map<String, Long> turmaMap) {
        this.turmaMap = turmaMap;
    }

    public Map<String, Long> getItemAvaliacao() {
        return itemAvaliacao;
    }

    public void setItemAvaliacao(Map<String, Long> itemAvaliacao) {
        this.itemAvaliacao = itemAvaliacao;
    }
}
